interceptors.go (1)

542-559: ⚠️ Potential issue | 🟠 Major

Stream context enrichment not propagated to handler.

The ctx is enriched with trace ID at lines 545-547, but handler(srv, stream) at line 549 receives the original stream whose Context() method returns the unenriched context. Downstream handlers reading stream.Context() will not see the trace ID.

This was flagged in a previous review. The fix requires wrapping the stream:

Proposed fix

+type serverStreamWithContext struct {
+	grpc.ServerStream
+	ctx context.Context
+}
+
+func (s *serverStreamWithContext) Context() context.Context {
+	return s.ctx
+}

Then at the call site:

-		err = handler(srv, stream)
+		err = handler(srv, &serverStreamWithContext{ServerStream: stream, ctx: ctx})

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@interceptors.go` around lines 542 - 559, The handler is called with the
original grpc.ServerStream so its Context() doesn't include the added trace
info; wrap the stream with a small type (e.g., streamWithContext or
wrappedStream) that embeds grpc.ServerStream and overrides Context() to return
the enriched ctx (the ctx produced after notifier.SetTraceId and
loggers.AddToLogContext) and pass that wrapped stream into handler(srv,
wrappedStream) inside ServerErrorStreamInterceptor so downstream handlers
reading stream.Context() see the trace id.

interceptors.go (2)

169-218: ⚠️ Potential issue | 🟠 Major

Make chain helpers re-entrant (shared index currently breaks repeated next calls).

All three helpers mutate a shared i. If any interceptor invokes next more than once, subsequent invocations skip part of the chain.

Proposed fix (index-capturing recursion)

 func chainUnaryServer(interceptors []grpc.UnaryServerInterceptor) grpc.UnaryServerInterceptor {
 	return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
-		var i int
-		var next grpc.UnaryHandler
-		next = func(ctx context.Context, req interface{}) (interface{}, error) {
-			if i == len(interceptors) {
-				return handler(ctx, req)
-			}
-			interceptor := interceptors[i]
-			i++
-			return interceptor(ctx, req, info, next)
-		}
-		return next(ctx, req)
+		var call func(int, context.Context, interface{}) (interface{}, error)
+		call = func(i int, ctx context.Context, req interface{}) (interface{}, error) {
+			if i == len(interceptors) {
+				return handler(ctx, req)
+			}
+			return interceptors[i](ctx, req, info, func(nextCtx context.Context, nextReq interface{}) (interface{}, error) {
+				return call(i+1, nextCtx, nextReq)
+			})
+		}
+		return call(0, ctx, req)
 	}
 }

 func chainUnaryClient(interceptors []grpc.UnaryClientInterceptor) grpc.UnaryClientInterceptor {
 	return func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
-		var i int
-		var next grpc.UnaryInvoker
-		next = func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, opts ...grpc.CallOption) error {
-			if i == len(interceptors) {
-				return invoker(ctx, method, req, reply, cc, opts...)
-			}
-			interceptor := interceptors[i]
-			i++
-			return interceptor(ctx, method, req, reply, cc, next, opts...)
-		}
-		return next(ctx, method, req, reply, cc, opts...)
+		var call func(int, context.Context, string, interface{}, interface{}, *grpc.ClientConn, ...grpc.CallOption) error
+		call = func(i int, ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, opts ...grpc.CallOption) error {
+			if i == len(interceptors) {
+				return invoker(ctx, method, req, reply, cc, opts...)
+			}
+			return interceptors[i](ctx, method, req, reply, cc, func(nextCtx context.Context, nextMethod string, nextReq, nextReply interface{}, nextCC *grpc.ClientConn, nextOpts ...grpc.CallOption) error {
+				return call(i+1, nextCtx, nextMethod, nextReq, nextReply, nextCC, nextOpts...)
+			}, opts...)
+		}
+		return call(0, ctx, method, req, reply, cc, opts...)
 	}
 }

 func chainStreamClient(interceptors []grpc.StreamClientInterceptor) grpc.StreamClientInterceptor {
 	return func(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string, streamer grpc.Streamer, opts ...grpc.CallOption) (grpc.ClientStream, error) {
-		var i int
-		var next grpc.Streamer
-		next = func(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string, opts ...grpc.CallOption) (grpc.ClientStream, error) {
-			if i == len(interceptors) {
-				return streamer(ctx, desc, cc, method, opts...)
-			}
-			interceptor := interceptors[i]
-			i++
-			return interceptor(ctx, desc, cc, method, next, opts...)
-		}
-		return next(ctx, desc, cc, method, opts...)
+		var call func(int, context.Context, *grpc.StreamDesc, *grpc.ClientConn, string, ...grpc.CallOption) (grpc.ClientStream, error)
+		call = func(i int, ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string, opts ...grpc.CallOption) (grpc.ClientStream, error) {
+			if i == len(interceptors) {
+				return streamer(ctx, desc, cc, method, opts...)
+			}
+			return interceptors[i](ctx, desc, cc, method, func(nextCtx context.Context, nextDesc *grpc.StreamDesc, nextCC *grpc.ClientConn, nextMethod string, nextOpts ...grpc.CallOption) (grpc.ClientStream, error) {
+				return call(i+1, nextCtx, nextDesc, nextCC, nextMethod, nextOpts...)
+			}, opts...)
+		}
+		return call(0, ctx, desc, cc, method, opts...)
 	}
 }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@interceptors.go` around lines 169 - 218, The chain helpers (chainUnaryServer,
chainUnaryClient, chainStreamClient) use a shared mutable index `i`, so if any
interceptor calls `next` more than once the second call skips interceptors; fix
by making the recursion index-local (capture the index per invocation) — replace
the shared `i`/single `next` pattern with a recursive function that takes an
index parameter (e.g. chain(idx int) or nextAt(index int)) and invokes the
appropriate interceptor or final handler/invoker/streamer using that index,
incrementing the index only for the recursive call; apply the same
index-capturing recursion change to the UnaryServer, UnaryClient (use invoker),
and StreamClient (use streamer) helpers so repeated `next` calls traverse the
chain correctly.

---

133-135: ⚠️ Potential issue | 🟡 Minor

Correct SetClientMetricsOptions lifecycle docs.

This is a client-side configuration API, so “before the server starts” is the wrong boundary. It should say it must be called during init before any RPCs are made.

Proposed doc fix

 // SetClientMetricsOptions appends gRPC client metrics options.
-// Must be called during initialization, before the server starts. Not safe for concurrent use.
+// Must be called during initialization, before any RPCs are made. Not safe for concurrent use.
 func SetClientMetricsOptions(opts ...grpcprom.ClientMetricsOption) {
 	cltMetricsOpts = append(cltMetricsOpts, opts...)
 }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@interceptors.go` around lines 133 - 135, Update the doc comment for
SetClientMetricsOptions to reflect its client-side lifecycle: replace “Must be
called during initialization, before the server starts. Not safe for concurrent
use.” with a line stating it must be called during initialization before any
RPCs are made and is not safe for concurrent use, so callers should configure it
prior to making client calls; reference the function name
SetClientMetricsOptions in the comment so it's clear which API is affected.

go.mod (1)

187-187: Move gomarkdoc from indirect to direct tooling requirement.

gomarkdoc is explicitly listed in the tool (...) block (lines 278–282), making it a direct tooling dependency. Remove the // indirect marker on line 187 to follow the Go convention that explicitly required tools remain as direct requires.

Proposed go.mod adjustment

-	github.com/princjef/gomarkdoc v1.1.0 // indirect
+	github.com/princjef/gomarkdoc v1.1.0

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@go.mod` at line 187, The go.mod currently marks github.com/princjef/gomarkdoc
as an indirect dependency; update the requirement so gomarkdoc is a direct
tooling requirement by removing the "// indirect" marker for
github.com/princjef/gomarkdoc v1.1.0 and ensuring it remains declared in the
tool (...) block; edit the go.mod entry for the module name
"github.com/princjef/gomarkdoc" to remove the indirect comment so it is treated
as a direct tooling requirement.